.TH std::weak_ptr::use_count 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::weak_ptr::use_count \- std::weak_ptr::use_count

.SH Synopsis
   long use_count() const noexcept;  \fI(since C++11)\fP

   Returns the number of shared_ptr instances that share ownership of the managed
   object, or 0 if the managed object has already been deleted, i.e. *this is empty.

.SH Parameters

   \fI(none)\fP

.SH Return value

   The number of shared_ptr instances sharing the ownership of the managed object at
   the instant of the call.

.SH Notes

   expired() may be faster than use_count(). This function is inherently racy, if the
   managed object is shared among threads that might be creating and destroying copies
   of the shared_ptr: then, the result is reliable only if it matches the number of
   copies uniquely owned by the calling thread, or zero; any other value may become
   stale before it can be used.

.SH Example


// Run this code

 #include <iostream>
 #include <memory>

 std::weak_ptr<int> gwp;

 void observe_gwp()
 {
     std::cout << "use_count(): " << gwp.use_count() << "\\t id: ";
     if (auto sp = gwp.lock())
         std::cout << *sp << '\\n';
     else
         std::cout << "??\\n";
 }

 void share_recursively(std::shared_ptr<int> sp, int depth)
 {
     observe_gwp(); // : 2 3 4
     if (1 < depth)
         share_recursively(sp, depth - 1);
     observe_gwp(); // : 4 3 2
 }

 int main()
 {
     observe_gwp();
     {
         auto sp = std::make_shared<int>(42);
         gwp = sp;
         observe_gwp(); // : 1
         share_recursively(sp, 3); // : 2 3 4 4 3 2
         observe_gwp(); // : 1
     }
     observe_gwp(); // : 0
 }

.SH Output:

 use_count(): 0   id: ??
 use_count(): 1   id: 42
 use_count(): 2   id: 42
 use_count(): 3   id: 42
 use_count(): 4   id: 42
 use_count(): 4   id: 42
 use_count(): 3   id: 42
 use_count(): 2   id: 42
 use_count(): 1   id: 42
 use_count(): 0   id: ??

.SH See also

   expired checks whether the referenced object was already deleted
           \fI(public member function)\fP
